﻿#include <iostream>
#include <initializer_list>
#include <list>
#include <map>
#include <set>
#include <algorithm>
#include <vector>

using namespace std;
class Date
{
public:
	//explicit Date(int year, int month, int day)
	Date(int year, int month, int day)
		:_year(year)
		, _month(month)
		, _day(day)
	{
		cout << "Date(int year, int month, int day)" << endl;
	}

private:
	int _year;
	int _month;
	int _day;
};
//int main()
//{
//
//	//Date d1(2023, 1, 1);
//	//Date d2 = { 2023,1,1 };
//	//Date d3{2023,1,1};
//
//	//int x1 = 1;
//	////可以用{}初始化变量或者数组，可以不加=
//	//int x2 = { 2 };
//	//int x3{ 3 };
//
//	//int arr[]{ 1,2,3,4,5 };
//	//int arr2[5]{ 0 };
//
//	//vector<int> v1 = { 1,1,1,1 };
//	//vector<int> v2{ 1,1,1,1 };
//
//	//list<int> ls1 = { 1,2,3,4,5 };
//	//list<int> ls2{ 1,2,3,4,5 };
//
//	//map<int, int> m1 = { {1,1},{2,2} };
//	//map<int, int> m2 { {1,1},{2,2} };
//
//
//
//	//auto i1 = { 10,20,30,1,1,2,2,2,2,2,2,1,1,1,1,1,1,1,1,2,1,1,2 };
//	//auto i2 = { 10,20,30 };
//	//cout << typeid(i1).name() << endl;
//	//cout << typeid(i2).name() << endl;
//
//	//const int x = 1;
//	//double y = 2.2;
//
//	//decltype(x * y) ret; // ret的类型是double
//	//decltype(&x) p;	//p的类型是const int*
//
//	//cout << typeid(ret).name() << endl;
//	//cout << typeid(p).name() << endl;
//
//	//int a = 10;
//	//int&& ret = std::move(a);
//	//a = 20;
//
//	//int&& ret1 = 10;
//	return 0;
//}

//void Fun(int& x) { 
//	cout << "左值引用" << endl; 
//}
//void Fun(const int& x) { 
//	cout << "const 左值引用" << endl; 
//}
//
//void Fun(int&& x) { 
//	cout << "右值引用" << endl; 
//}
//void Fun(const int&& x) { 
//	cout << "const 右值引用" << endl; 
//}
//// 万能引用(引用折叠)：既可以引用左值，也可以引用右值
//template<class T>
//void PerfectForward(T&& t)
//{
//	Fun(forward<T>(t));
//}
//int main()
//{
//
//	PerfectForward(100);
//
//	int a;
//	PerfectForward(a);            // 左值
//	PerfectForward(std::move(a)); // 右值
//
//	const int b = 8;
//	PerfectForward(b);		      // const 左值
//	PerfectForward(std::move(b)); // const 右值
//	return 0;
//}



// Args是一个模板参数包，args是一个函数形参参数包
// 声明一个参数包Args...args，这个参数包中可以包含0到任意个模板参数。

//void ShowList()
//{
//	cout << endl;
//}
//template <class T,class ...Args>
//void ShowList(const T& val,Args... args)
//{
//	//cout << sizeof...(args) << endl;
//	cout << val << " ";
//	ShowList(args...);
//}

//template <class T>
//void PrintArg(T t)
//{
//	cout << t << " ";
//}
////展开函数
//template <class ...Args>
//void ShowList(Args... args)
//{
//	int arr[] = { (PrintArg(args), 0)... };
//	cout << endl;
//}
//int main()
//{
//	/*ShowList(1);
//	ShowList(1, 'A');
//	ShowList(1, 'A', std::string("sort"));*/
//
//	cout << [](int x,int y)->int {return x + y; }(1,2) << endl;
//	auto add = []()->int{return 1 + 2; };
//	cout << add() << endl;
//	return 0;
//}


struct Goods
{
	string _name;  // 名字
	double _price; // 价格
	int _evaluate; // 评价
	Goods(const char* str, double price, int evaluate)
		:_name(str)
		, _price(price)
		, _evaluate(evaluate)
	{}
};

//int main()
//{
//	vector<Goods> v = { { "苹果", 2.1, 5 }, { "香蕉", 3, 4 }, { "橙子", 2.2, 3 }, { "菠萝", 1.5, 4 } };
//
//	sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2)->bool { return g1._price < g2._price; });
//
//	sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2)->bool { return g1._price > g2._price; });
//
//	sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2)->bool { return g1._evaluate < g2._evaluate; });
//
//	sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2)->bool { return g1._evaluate > g2._evaluate; });
//}

//int main()
//{
//	//int x = 1, y = 0;
//	/*auto swap = [](int& x, int& y) {
//		int tem = x;
//		x = y;
//		y = tem;
//	};
//	swap(x, y);
//	cout << x <<" "<< y << endl;*/
//
//
//	////传值捕捉
//	//int x = 1, y = 0;
//	//auto swap2 = [x, y]() mutable 
//	//{
//	//	int tmp = x;
//	//	x = y;
//	//	y = tmp;
//	//};
//
//	//swap2();
//	//cout << x << " " << y << endl;
//
//
//	//引用捕捉
//	/*int x = 1, y = 0;
//	auto swap3 = [&x, &y]() 
//	{
//		int tmp = x;
//		x = y;
//		y = tmp;
//	};
//
//	swap3();
//	cout << x << " " << y << endl;*/
//
//	int x = 1, y = 0;
//	auto swap = [=]() mutable
//	{
//		int tmp = x;
//		x = y;
//		y = tmp;
//	};
//	return 0;
//}

#include <thread>
#include <mutex>

int main()
{
	mutex mtx;
	condition_variable var;
	int i = 1;
	int n = 100;
	thread t1([&, n]() {
		while (i < n)
		{
			unique_lock<mutex> ulock(mtx);
			if (i % 2 == 0)
				var.wait(ulock);
			cout << "线程1"<< ":" << i << endl;
			i++;
			var.notify_one();


		}
		});
	thread t2([&, n]() {
		while (i < n)
		{
			unique_lock<mutex> ulock(mtx);

			if (i % 2 == 1)
				var.wait(ulock);
			cout <<"线程2" << ":" << i << endl;
			i++;

			var.notify_one();


		}
		});

	t1.join();
	t2.join();
	return 0;
}